// 高校推荐算法工具函数

/**
 * 判断文理科类别
 * @param {Array} subjects - 选择的科目数组
 * @returns {string} - '理工' 或 '文史'
 */
export function getSubjectCategory(subjects) {
  if (subjects.includes('物理')) {
    return '理工';
  } else if (subjects.includes('历史')) {
    return '文史';
  }
  return '理工'; // 默认理工
}

/**
 * 根据科类筛选数据
 * @param {string} category - 科类别 ('理工' 或 '文史')
 * @param {Array} allData - 所有院校数据
 * @returns {Array} - 对应科类的院校数据
 */
export function getDataByCategory(category, allData) {
  if (!Array.isArray(allData)) {
    console.warn('数据格式错误，应为数组');
    return [];
  }
  return allData.filter(college => college.subject_category === category);
}

/**
 * 清理并解析分数（只取整数部分）
 * @param {string} scoreStr - 原始分数字符串
 * @returns {number} - 清理后的整数分数
 */
export function parseScore(scoreStr) {
  if (!scoreStr || scoreStr === '') return 0;
  const floatScore = parseFloat(scoreStr.toString().trim());
  return Math.floor(floatScore); // 只取整数部分
}

/**
 * 根据分数范围进行冲稳保分类
 * @param {number} userScore - 用户分数（整数）
 * @param {string|number} schoolMinScore - 学校最低分
 * @returns {string} - '冲'、'稳'、'保' 或 null
 */
export function categorizeByScore(userScore, schoolMinScore) {
  if (!schoolMinScore || schoolMinScore === '') return null;
  
  const cleanScore = parseScore(schoolMinScore);
  if (cleanScore === 0) return null;
  
  // 确保用户分数也是整数
  const userIntScore = Math.floor(userScore);
  
  // 新的分类规则：
  // 冲：学校分数在 [用户分数-5, 用户分数] 范围内
  // 稳：学校分数在 [用户分数-15, 用户分数-5) 范围内  
  // 保：学校分数在 [用户分数-45, 用户分数-15) 范围内
  
  if (cleanScore >= userIntScore - 5 && cleanScore <= userIntScore) {
    return '冲'; // 红色
  } else if (cleanScore >= userIntScore - 15 && cleanScore < userIntScore - 5) {
    return '稳'; // 蓝色
  } else if (cleanScore >= userIntScore - 45 && cleanScore < userIntScore - 15) {
    return '保'; // 绿色
  }
  
  return null; // 不显示
}

/**
 * 判断是否为省内院校（改进版）
 * @param {string} collegeName - 院校名称
 * @param {string} userProvince - 用户所在省份
 * @returns {boolean} - 是否为省内院校
 */
export function isInProvince(collegeName, userProvince) {
  if (!collegeName || !userProvince) return false;
  
  // 清理省份名称，移除"省"、"市"等后缀
  const cleanUserProvince = userProvince.replace(/[省市自治区特别行政区]/g, '');
  
  // 检查院校名称是否包含省份简称
  const provinceMap = {
    '北京': ['北京'],
    '天津': ['天津'],
    '河北': ['河北'],
    '山西': ['山西'],
    '内蒙古': ['内蒙古', '内蒙'],
    '辽宁': ['辽宁'],
    '吉林': ['吉林'],
    '黑龙江': ['黑龙江'],
    '上海': ['上海'],
    '江苏': ['江苏'],
    '浙江': ['浙江'],
    '安徽': ['安徽'],
    '福建': ['福建'],
    '江西': ['江西'],
    '山东': ['山东'],
    '河南': ['河南'],
    '湖北': ['湖北'],
    '湖南': ['湖南'],
    '广东': ['广东'],
    '广西': ['广西'],
    '海南': ['海南'],
    '重庆': ['重庆'],
    '四川': ['四川'],
    '贵州': ['贵州'],
    '云南': ['云南'],
    '西藏': ['西藏'],
    '陕西': ['陕西'],
    '甘肃': ['甘肃'],
    '青海': ['青海'],
    '宁夏': ['宁夏'],
    '新疆': ['新疆'],
    '香港': ['香港'],
    '澳门': ['澳门'],
    '台湾': ['台湾']
  };
  
  const matchTerms = provinceMap[cleanUserProvince] || [cleanUserProvince];
  
  return matchTerms.some(term => collegeName.includes(term));
}

/**
 * 检查科目匹配（基础实现）
 * @param {Array} userSubjects - 用户选择的科目
 * @param {Object} college - 院校信息
 * @returns {boolean} - 是否匹配
 */
export function checkSubjectMatch(userSubjects, college) {
  // 基础实现：所有院校都匹配
  // 后续可以根据具体的专业要求数据来完善这个逻辑
  return true;
}

/**
 * 进行高校推荐（修正版）
 * @param {Object} params - 推荐参数
 * @returns {Object} - 推荐结果
 */
export function getRecommendations(params) {
  const { userProvince, userScore, subjects, schoolData } = params;
  
  // 判断文理科
  const category = getSubjectCategory(subjects);
  const data = getDataByCategory(category, schoolData);
  
  // 确保用户分数为整数
  const userIntScore = Math.floor(userScore);
  
  // 初始化结果对象
  const result = {
    rush: { local: [], external: [] },
    stable: { local: [], external: [] },
    safe: { local: [], external: [] }
  };
  
  // 遍历院校数据进行分类
  data.forEach(college => {
    // 检查科目匹配
    if (!checkSubjectMatch(subjects, college)) {
      return;
    }
    
    const scoreCategory = categorizeByScore(userIntScore, college.minimum_score);
    
    if (scoreCategory) {
      const isLocal = isInProvince(college.college_name, userProvince);
      const provinceKey = isLocal ? 'local' : 'external';
      
      // 将中文分类映射为英文key
      const categoryMap = { '冲': 'rush', '稳': 'stable', '保': 'safe' };
      const englishCategory = categoryMap[scoreCategory];
      
      const cleanMinScore = parseScore(college.minimum_score);
      
      result[englishCategory][provinceKey].push({
        ...college,
        scoreDiff: userIntScore - cleanMinScore, // 使用整数差值
        cleanMinScore: cleanMinScore
      });
    }
  });
  
  // 对每个分类的院校按照学校分数排序并限制为前3所
  Object.keys(result).forEach(category => {
    Object.keys(result[category]).forEach(provinceType => {
      result[category][provinceType].sort((a, b) => {
        if (category === 'rush') {
          return b.cleanMinScore - a.cleanMinScore; // 冲：按学校分数从高到低
        } else {
          return b.cleanMinScore - a.cleanMinScore; // 稳、保：按学校分数从高到低
        }
      });
      
      // 只保留前3所院校
      result[category][provinceType] = result[category][provinceType].slice(0, 3);
    });
  });
  
  return result;
}

/**
 * 格式化分数差显示（整数显示）
 * @param {number} diff - 分数差
 * @returns {string} - 格式化后的分数差
 */
export function formatScoreDiff(diff) {
  const intDiff = Math.floor(diff);
  if (intDiff > 0) {
    return `+${intDiff}`;
  } else if (intDiff < 0) {
    return `${intDiff}`;
  } else {
    return '0';
  }
}

/**
 * 加载学校数据的辅助函数
 * @param {Array} rawData - 原始数据数组
 * @returns {Object} - 分类后的数据对象
 */
export function processSchoolData(rawData) {
  if (!Array.isArray(rawData)) {
    console.error('原始数据格式错误');
    return { wkData: [], lkData: [] };
  }
  
  const wkData = rawData.filter(item => item.subject_category === '文史');
  const lkData = rawData.filter(item => item.subject_category === '理工');
  
  return { wkData, lkData };
} 